import 'dart:async';
import 'dart:convert';
import 'package:flutter/foundation.dart';
import 'package:shared_preferences/shared_preferences.dart';

/// 数据管理服务
/// 统一管理数据库服务和连接管理功能
class DataManagementService {
  static final DataManagementService _instance = DataManagementService._internal();
  factory DataManagementService() => _instance;
  DataManagementService._internal();

  /// 测试数据库连接
  Future<bool> testConnection(Map<String, dynamic> config) async {
    try {
      // 模拟连接测试
      await Future.delayed(const Duration(seconds: 2));
      
      // 根据数据库类型进行不同的测试
      final dbType = config['type'];
      switch (dbType) {
        case 'mysql':
        case 'mariadb':
          // MySQL/MariaDB连接测试逻辑
          break;
        case 'postgresql':
          // PostgreSQL连接测试逻辑
          break;
        case 'sqlserver':
          // SQL Server连接测试逻辑
          break;
        case 'sqlite':
          // SQLite连接测试逻辑
          break;
        default:
          throw Exception('不支持的数据库类型: $dbType');
      }
      
      // 模拟测试成功
      return true;
    } catch (e) {
      debugPrint('数据库连接测试失败: $e');
      return false;
    }
  }

  /// 获取数据库表列表
  Future<List<String>> getTableList(Map<String, dynamic> config) async {
    try {
      // 模拟获取表列表
      await Future.delayed(const Duration(seconds: 1));
      
      // 返回模拟的表列表
      return [
        'users',
        'projects',
        'tasks',
        'comments',
        'attachments',
        'logs',
        'settings',
        'permissions',
      ];
    } catch (e) {
      debugPrint('获取表列表失败: $e');
      rethrow;
    }
  }

  /// 查询表数据
  Future<List<Map<String, dynamic>>> queryTableData(
    Map<String, dynamic> config,
    String tableName, {
    int limit = 100,
    int offset = 0,
  }) async {
    try {
      // 模拟查询数据
      await Future.delayed(const Duration(milliseconds: 500));
      
      // 根据表名返回不同的模拟数据
      if (tableName == 'users') {
        return [
          {
            'id': 1,
            'username': 'admin',
            'email': 'admin@example.com',
            'created_at': '2024-01-01 12:00:00',
            'updated_at': '2024-01-01 12:00:00',
          },
          {
            'id': 2,
            'username': 'user1',
            'email': 'user1@example.com',
            'created_at': '2024-01-02 12:00:00',
            'updated_at': '2024-01-02 12:00:00',
          },
        ];
      } else if (tableName == 'projects') {
        return [
          {
            'id': 1,
            'name': '项目A',
            'description': '这是项目A的描述',
            'status': '进行中',
            'created_at': '2024-01-01 12:00:00',
            'updated_at': '2024-01-01 12:00:00',
          },
          {
            'id': 2,
            'name': '项目B',
            'description': '这是项目B的描述',
            'status': '已完成',
            'created_at': '2024-01-02 12:00:00',
            'updated_at': '2024-01-02 12:00:00',
          },
        ];
      } else {
        // 默认模拟数据
        return [
          {
            'id': 1,
            'name': tableName,
            'description': '示例数据',
            'created_at': '2024-01-01 12:00:00',
            'updated_at': '2024-01-01 12:00:00',
          },
        ];
      }
    } catch (e) {
      debugPrint('查询表数据失败: $e');
      rethrow;
    }
  }

  /// 获取表结构信息
  Future<List<Map<String, dynamic>>> getTableSchema(
    Map<String, dynamic> config,
    String tableName,
  ) async {
    try {
      // 模拟获取表结构
      await Future.delayed(const Duration(milliseconds: 300));
      
      // 返回模拟的表结构信息
      return [
        {
          'column_name': 'id',
          'data_type': 'int',
          'is_nullable': false,
          'is_primary_key': true,
        },
        {
          'column_name': 'name',
          'data_type': 'varchar',
          'is_nullable': false,
          'is_primary_key': false,
        },
        {
          'column_name': 'description',
          'data_type': 'text',
          'is_nullable': true,
          'is_primary_key': false,
        },
        {
          'column_name': 'created_at',
          'data_type': 'datetime',
          'is_nullable': false,
          'is_primary_key': false,
        },
        {
          'column_name': 'updated_at',
          'data_type': 'datetime',
          'is_nullable': true,
          'is_primary_key': false,
        },
      ];
    } catch (e) {
      debugPrint('获取表结构失败: $e');
      rethrow;
    }
  }
  
  /// 保存数据库连接配置
  static Future<void> saveConnection(Map<String, dynamic> connectionConfig) async {
    final prefs = await SharedPreferences.getInstance();
    
    // 获取现有的连接列表
    final connections = await getConnections();
    
    // 检查是否已存在同名连接
    final existingIndex = connections.indexWhere(
      (conn) => conn['name'] == connectionConfig['name']
    );
    
    if (existingIndex >= 0) {
      // 更新现有连接
      connections[existingIndex] = connectionConfig;
    } else {
      // 添加新连接
      connections.add(connectionConfig);
    }
    
    // 保存更新后的连接列表
    final String connectionsString = json.encode(connections);
    await prefs.setString('db_connections', connectionsString);
  }
  
  /// 获取所有保存的数据库连接
  static Future<List<Map<String, dynamic>>> getConnections() async {
    final prefs = await SharedPreferences.getInstance();
    final String? connectionsString = prefs.getString('db_connections');
    
    if (connectionsString != null) {
      final List<dynamic> connections = json.decode(connectionsString);
      return connections.map((conn) => Map<String, dynamic>.from(conn)).toList();
    }
    
    return [];
  }
  
  /// 根据名称获取数据库连接
  static Future<Map<String, dynamic>?> getConnectionByName(String name) async {
    final connections = await getConnections();
    try {
      return connections.firstWhere((conn) => conn['name'] == name);
    } catch (e) {
      return null;
    }
  }
  
  /// 删除数据库连接
  static Future<void> deleteConnection(String name) async {
    final prefs = await SharedPreferences.getInstance();
    final connections = await getConnections();
    
    // 移除指定名称的连接
    connections.removeWhere((conn) => conn['name'] == name);
    
    // 保存更新后的连接列表
    final String connectionsString = json.encode(connections);
    await prefs.setString('db_connections', connectionsString);
  }
  
  /// 更新数据库连接
  static Future<void> updateConnection(Map<String, dynamic> connectionConfig) async {
    await saveConnection(connectionConfig);
  }
}